SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Vertex buffer object</title>

</head>

Vertex buffer object

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

A vertex buffer object (VBO) is an <a href="OpenGL" title="OpenGL">OpenGL</a> feature that provides methods for uploading vertex data (<a href="Vertex_(geometry)" title="Vertex (geometry)">position</a>, <a href="Normal_vector" class="mw-redirect" title="Normal vector">normal vector</a>, color, etc.) to the video device for non-immediate-mode rendering. VBOs offer substantial performance gains over <a href="Immediate_mode_(computer_graphics)" title="Immediate mode (computer graphics)">immediate mode rendering</a> primarily because the data reside in video device memory rather than system memory and so it can be rendered directly by the video device. These are equivalent to <a href="Vertex_buffer" class="mw-redirect" title="Vertex buffer">vertex buffers</a> in <a href="Direct3D" title="Direct3D">Direct3D</a>.

The vertex buffer object specification has been standardized by the <a rel="nofollow" class="external text" href="http://www.opengl.org/about/arb/">OpenGL Architecture Review Board</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20111124074301/http://www.opengl.org/about/arb/">Archived</a> 2011-11-24 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> as of <a href="OpenGL" title="OpenGL">OpenGL</a> Version 1.5 (in 2003). Similar functionality was available before the standardization of VBOs via the <a href="Nvidia" title="Nvidia">Nvidia</a>-created extension "vertex array range"<a href="#cite_note-1">[1]</a> or <a href="ATI_Technologies" title="ATI Technologies">ATI</a>'s "vertex array object"<a href="#cite_note-2">[2]</a> extension.

<div class="mw-heading mw-heading2"><h2 id="Basic_VBO_functions">Basic VBO functions</h2></div>

The following functions form the core of VBO access and manipulation:

<dl><dd>In OpenGL 1.4:

<dl><dd>glGenBuffersARB(sizei n, uint *buffers)</dd>

<dd>Generates a new VBO and returns its ID number as an unsigned integer. Id 0 is reserved.</dd></dl></dd></dl>

<dl><dd><dl><dd>glBindBufferARB(enum target, uint buffer)</dd>

<dd>Use a previously created buffer as the active VBO.</dd></dl></dd></dl>

<dl><dd><dl><dd>glBufferDataARB(enum target, sizeiptrARB size, const void *data, enum usage)</dd>

<dd>Upload data to the active VBO.</dd></dl></dd></dl>

<dl><dd><dl><dd>glDeleteBuffersARB(sizei n, const uint *buffers)</dd>

<dd>Deletes the specified number of VBOs from the supplied array or VBO id.</dd></dl></dd></dl>

<dl><dd>In OpenGL 2.1,<a href="#cite_note-3">[3]</a> OpenGL 3.x<a href="#cite_note-4">[4]</a> and OpenGL 4.x:<a href="#cite_note-5">[5]</a>

<dl><dd>glGenBuffers(sizei n, uint *buffers)</dd>

<dd>Generates a new VBO and returns its ID number as an unsigned integer. Id 0 is reserved.</dd></dl></dd></dl>

<dl><dd><dl><dd>glBindBuffer(enum target, uint buffer)</dd>

<dd>Use a previously created buffer as the active VBO.</dd></dl></dd></dl>

<dl><dd><dl><dd>glBufferData(enum target, sizeiptrARB size, const void *data, enum usage)</dd>

<dd>Upload data to the active VBO.</dd></dl></dd></dl>

<dl><dd><dl><dd>glDeleteBuffers(sizei n, const uint *buffers)</dd>

<dd>Deletes the specified number of VBOs from the supplied array or VBO id.</dd></dl></dd></dl>

<div class="mw-heading mw-heading2"><h2 id="Example_usage">Example usage</h2></div>

<div class="mw-heading mw-heading3"><h3 id="In_C,_using_OpenGL_2.1">In C, using OpenGL 2.1</h3></div>

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>//Initialise VBO - do only once, at start of program

//Create a variable to hold the VBO identifier

GLuint triangleVBO;

//Vertices of a triangle (counter-clockwise winding)

float data[] = {1.0, 0.0, 1.0, 0.0, 0.0, -1.0, -1.0, 0.0, 1.0};

//try float data[] = {0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0}; if the above doesn't work.

//Create a new VBO and use the variable id to store the VBO id

glGenBuffers(1, &triangleVBO);

//Make the new VBO active

glBindBuffer(GL_ARRAY_BUFFER, triangleVBO);

//Upload vertex data to the video device

glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);

//Make the new VBO active. Repeat here in case it has changed since initialisation

//Draw Triangle from VBO - do each time window, view point or data changes

//Establish its 3 coordinates per vertex with zero stride in this array; necessary here

glVertexPointer(3, GL_FLOAT, 0, NULL);

//Establish array contains vertices (not normals, colours, texture coords etc)

glEnableClientState(GL_VERTEX_ARRAY);

//Actually draw the triangle, giving the number of vertices provided

glDrawArrays(GL_TRIANGLES, 0, sizeof(data) / sizeof(float) / 3);

//Force display to be drawn now

glFlush();

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="In_C,_using_OpenGL_3.x_and_OpenGL_4.x">In C, using OpenGL 3.x and OpenGL 4.x</h3></div>

Vertex Shader:

<div class="mw-highlight mw-highlight-lang-glsl mw-content-ltr" dir="ltr"><pre>/*----------------- "exampleVertexShader.vert" -----------------*/

#version 150 // Specify which version of GLSL we are using.

// in_Position was bound to attribute index 0("shaderAttribute")

in vec3 in_Position;

void main()

{

gl_Position = vec4(in_Position.x, in_Position.y, in_Position.z, 1.0);

}

/*--------------------------------------------------------------*/

</pre></div>

Fragment Shader:

<div class="mw-highlight mw-highlight-lang-glsl mw-content-ltr" dir="ltr"><pre>/*---------------- "exampleFragmentShader.frag" ----------------*/

#version 150 // Specify which version of GLSL we are using.

precision highp float; // Video card drivers require this line to function properly

out vec4 fragColor;

void main()

{

fragColor = vec4(1.0,1.0,1.0,1.0); //Set colour of each fragment to WHITE

}

/*--------------------------------------------------------------*/

</pre></div>

Main OpenGL Program:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>/*--------------------- Main OpenGL Program ---------------------*/

/* Create a variable to hold the VBO identifier */

GLuint triangleVBO;

/* This is a handle to the shader program */

GLuint shaderProgram;

/* These pointers will receive the contents of our shader source code files */

GLchar *vertexSource, *fragmentSource;

/* These are handles used to reference the shaders */

GLuint vertexShader, fragmentShader;

const unsigned int shaderAttribute = 0;

/* Vertices of a triangle (counter-clockwise winding) */

float data[3][3] = {

{ 0.0, 1.0, 0.0 },

{ -1.0, -1.0, 0.0 },

{ 1.0, -1.0, 0.0 }

};

/*---------------------- Initialise VBO - (Note: do only once, at start of program) ---------------------*/

/* Create a new VBO and use the variable "triangleVBO" to store the VBO id */

/* Make the new VBO active */

/* Upload vertex data to the video device */

/* Specify that our coordinate data is going into attribute index 0(shaderAttribute), and contains three floats per vertex */

glVertexAttribPointer(shaderAttribute, 3, GL_FLOAT, GL_FALSE, 0, 0);

/* Enable attribute index 0(shaderAttribute) as being used */

glEnableVertexAttribArray(shaderAttribute);

/* Make the new VBO active. */

/*-------------------------------------------------------------------------------------------------------*/

/*--------------------- Load Vertex and Fragment shaders from files and compile them --------------------*/

/* Read our shaders into the appropriate buffers */

vertexSource = filetobuf("exampleVertexShader.vert");

fragmentSource = filetobuf("exampleFragmentShader.frag");

/* Assign our handles a "name" to new shader objects */

vertexShader = glCreateShader(GL_VERTEX_SHADER);

fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

/* Associate the source code buffers with each handle */

glShaderSource(vertexShader, 1, (const GLchar**)&vertexSource, 0);

glShaderSource(fragmentShader, 1, (const GLchar**)&fragmentSource, 0);

/* Free the temporary allocated memory */

free(vertexSource);

free(fragmentSource);

/* Compile our shader objects */

glCompileShader(vertexShader);

glCompileShader(fragmentShader);

/*-------------------------------------------------------------------------------------------------------*/

/*-------------------- Create shader program, attach shaders to it and then link it ---------------------*/

/* Assign our program handle a "name" */

shaderProgram = glCreateProgram();

/* Attach our shaders to our program */

glAttachShader(shaderProgram, vertexShader);

/* Bind attribute index 0 (shaderAttribute) to in_Position*/

/* "in_Position" will represent "data" array's contents in the vertex shader */

glBindAttribLocation(shaderProgram, shaderAttribute, "in_Position");

/* Link shader program*/

glLinkProgram(shaderProgram);

/*-------------------------------------------------------------------------------------------------------*/

/* Set shader program as being actively used */

glUseProgram(shaderProgram);

/* Set background colour to BLACK */

glClearColor(0.0, 0.0, 0.0, 1.0);

/* Clear background with BLACK colour */

glClear(GL_COLOR_BUFFER_BIT);

/* Actually draw the triangle, giving the number of vertices provided by invoke glDrawArrays

while telling that our data is a triangle and we want to draw 0-3 vertexes

*/

glDrawArrays(GL_TRIANGLES, 0, (sizeof(data) / 3) / sizeof(GLfloat));

/*---------------------------------------------------------------*/

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist reflist-columns references-column-width reflist-columns-2">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20040817124345/http://developer.nvidia.com/attach/7062">"GL_NV_vertex_array_range Whitepaper"</a>. Archived from the original on 2004-08-17. Retrieved 2024-06-24.</cite><code class="cs1-code">{{cite web}}</code>: CS1 maint: bot: original URL status unknown (link)

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20120704064126/http://oss.sgi.com/projects/ogl-sample/registry/ATI/vertex_array_object.txt">"ATI_vertex_array_object"</a>. Archived from <a rel="nofollow" class="external text" href="http://oss.sgi.com/projects/ogl-sample/registry/ATI/vertex_array_object.txt">the original</a> on 2012-07-04. Retrieved 2011-08-12.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20080217231212/http://www.opengl.org/sdk/docs/man/xhtml/">"OpenGL 2.1 function reference"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.opengl.org/sdk/docs/man/xhtml/">the original</a> on 2008-02-17. Retrieved 2008-02-11.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.opengl.org/sdk/docs/man3/">"OpenGL 3.3 function reference"</a>.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20130715225135/http://www.opengl.org/wiki/Category:Core_API_Reference">"OpenGL 4.2 function reference"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.opengl.org/wiki/Category:Core_API_Reference">the original</a> on 2013-07-15. Retrieved 2012-04-06.</cite>

</li>

</ol></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_vertex_buffer_object.txt">Vertex Buffer Object Whitepaper</a></li></ul></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-02" href="https://en.wikipedia.org/wiki/?title=Vertex_buffer_object&oldid=1303780438">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>